{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Registration_With_GANs.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm",
      "mount_file_id": "1Yg5lf-YjxwCJLnG-5bgwn-uXIMK_IZl-",
      "authorship_tag": "ABX9TyPHHgMrQmdLfkyeXKATQkO4",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/gwang37/RegistrationWithGANs/blob/main/Registration_With_GANs.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iCpCMEvosqi-"
      },
      "source": [
        "## 1. Prepare data and voxelMorph code\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3aZm4U9zrPiF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0a4142c5-9c29-4a78-dbd2-e8985bd57c6b"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive/')\n",
        "\n",
        "import os\n",
        "os.chdir('/content/drive/MyDrive/Colab Notebooks/final/RegistGans')"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive/; to attempt to forcibly remount, call drive.mount(\"/content/drive/\", force_remount=True).\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "69-rlU7qsx8W"
      },
      "source": [
        "import voxelmorph2d as vm2d\n",
        "import voxelmorph3d as vm3d\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import skimage.io as io\n",
        "from skimage.transform import resize\n",
        "import multiprocessing as mp\n",
        "from tqdm import tqdm\n",
        "import gc\n",
        "import time\n",
        "from sklearn.model_selection import train_test_split\n",
        "from matplotlib.lines import Line2D\n",
        "import numpy as np\n",
        "\n",
        "import torch\n",
        "import torchvision\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torchvision.datasets as dataset\n",
        "import torchvision.transforms as transforms\n",
        "import torch.optim as optim\n",
        "from torch.utils import data\n",
        "from torch.autograd import Variable\n",
        "\n",
        "\n",
        "use_gpu = torch.cuda.is_available()"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VJXkMXgBx2Zi"
      },
      "source": [
        "## Basic dataloading for MNIST.\n",
        "# Just to make sure it works for the rest of this notebook.\n",
        "\n",
        "transform = transforms.Compose([\n",
        "        # transforms.Resize(32),\n",
        "        # transforms.CenterCrop(32),\n",
        "        transforms.ToTensor(),\n",
        "        transforms.Normalize((0.5,), (0.5))\n",
        "])\n",
        "\n",
        "training = dataset.MNIST(root ='./data', transform = transform, train=True, download=True)\n",
        "testing =  dataset.MNIST(root ='./data', transform = transform, train=False, download=True)\n",
        "# traindata, valdata = data.Subset(training,range(0, 50000)), torch.utils.data.Subset(training, range(50000, 60000))\n",
        "# train_loader = data.DataLoader(dataset=traindata, batch_size = 100, shuffle=True)\n",
        "# test_loader = data.DataLoader(dataset=testing, batch_size = 100, shuffle=False)\n",
        "# vali_loader = data.DataLoader(dataset=valdata, batch_size = 100, shuffle=False)\n",
        "## \n",
        "\n"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 301
        },
        "id": "yW78F26l12GR",
        "outputId": "64d0fce1-1496-4555-95e9-a88791027cb4"
      },
      "source": [
        "print(training[0][0].shape)\n",
        "plt.imshow(training[0][0].squeeze(),cmap='gray', interpolation='none')"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "torch.Size([1, 28, 28])\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7fc9d2acbcc0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TV5Sbsup4Qaf"
      },
      "source": [
        "## 2. Preparing GANs"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HMkiaSRX2RWj",
        "outputId": "5ba33269-006c-4af5-f3f3-226e69791da7"
      },
      "source": [
        "digit = 5\n",
        "valIDX = 100\n",
        "idx = training.train_labels == digit\n",
        "# print(training[0][0].shape)\n",
        "\n",
        "x_digit = training.train_data[idx]\n",
        "y_digit = training.train_labels[idx]\n",
        "# print(x_digit[0].shape)\n",
        "\n",
        "x_train = x_digit[:-valIDX, ...]\n",
        "y_train = y_digit[:-valIDX]\n",
        "x_val = x_digit[-valIDX:, ...]  # this indexing means \"the last nb_val entries\" of the zeroth axis\n",
        "y_val = y_digit[-valIDX:]\n",
        "\n",
        "pad_amount = ((0, 0), (2,2), (2,2))\n",
        "\n",
        "# fix data\n",
        "x_train = np.pad(x_train, pad_amount, 'constant')\n",
        "x_val = np.pad(x_val, pad_amount, 'constant')\n",
        "print(x_train[0].shape)\n",
        "\n",
        "val_dataset = data.TensorDataset(torch.Tensor(x_val), y_val)\n",
        "\n",
        "\n",
        "# print(x_train.shape[0])"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(32, 32)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/torchvision/datasets/mnist.py:48: UserWarning: train_labels has been renamed targets\n",
            "  warnings.warn(\"train_labels has been renamed targets\")\n",
            "/usr/local/lib/python3.6/dist-packages/torchvision/datasets/mnist.py:58: UserWarning: train_data has been renamed data\n",
            "  warnings.warn(\"train_data has been renamed data\")\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "962ECiIK42PT"
      },
      "source": [
        "batch_size = 32\n",
        "\n",
        "if x_train.shape[0] % 2 ==0:\n",
        "  idx_moving, idx_fixed = train_test_split(range(x_train.shape[0]), test_size = .5)\n",
        "else:\n",
        "  idx_moving, idx_fixed = train_test_split(range(x_train.shape[0]-1), test_size = .5)\n",
        "training_set = data.TensorDataset(torch.Tensor(x_train[idx_moving, :]).unsqueeze(3),\n",
        "                                   torch.Tensor(x_train[idx_fixed, :]).unsqueeze(3))\n",
        "training_generator = data.DataLoader(training_set, batch_size=batch_size, shuffle=True)\n",
        "\n",
        "if x_val.shape[0] % 2 ==0:\n",
        "  idx_moving, idx_fixed = train_test_split(range(x_val.shape[0]), test_size = .5)\n",
        "else:\n",
        "  idx_moving, idx_fixed = train_test_split(range(x_val.shape[0]-1), test_size = .5)\n",
        "validation_set = data.TensorDataset(torch.Tensor(x_val[idx_moving, :]).unsqueeze(3),\n",
        "                                   torch.Tensor(x_val[idx_fixed, :]).unsqueeze(3))\n",
        "\n",
        "validation_generator = data.DataLoader(validation_set, batch_size=batch_size, shuffle=True)"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fqW4t6e5NJW1"
      },
      "source": [
        "# for moving, fixed in validation_generator:\n",
        "#   print(moving.shape)"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qWoHYtpS95GK"
      },
      "source": [
        "class VoxelMorph():\n",
        "    \"\"\"\n",
        "    VoxelMorph Class is a higher level interface for both 2D and 3D\n",
        "    Voxelmorph classes. It makes training easier and is scalable.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, input_dims, is_2d=False, use_gpu=False):\n",
        "        self.dims = input_dims\n",
        "        if is_2d:\n",
        "            self.vm = vm2d\n",
        "            self.voxelmorph = vm2d.VoxelMorph2d(input_dims[0] * 2, use_gpu)\n",
        "        else:\n",
        "            self.vm = vm3d\n",
        "            self.voxelmorph = vm3d.VoxelMorph3d(input_dims[0] * 2, use_gpu)\n",
        "        self.optimizer = optim.SGD(self.voxelmorph.parameters(), lr=1e-4, momentum=0.99)\n",
        "        self.params = {'batch_size': 3,\n",
        "                       'shuffle': True,\n",
        "                       'num_workers': 6,\n",
        "                       'worker_init_fn': np.random.seed(42)\n",
        "                       }\n",
        "        self.device = torch.device(\"cuda:0\" if use_gpu else \"cpu\")\n",
        "\n",
        "    def check_dims(self, x):\n",
        "        try:\n",
        "            if x.shape[1:] == self.dims:\n",
        "                return\n",
        "            else:\n",
        "                raise TypeError\n",
        "        except TypeError as e:\n",
        "            print(\"Invalid Dimension Error. The supposed dimension is \",\n",
        "                  self.dims, \"But the dimension of the input is \", x.shape[1:])\n",
        "\n",
        "    def forward(self, x):\n",
        "        self.check_dims(x)\n",
        "        return voxelmorph(x)\n",
        "\n",
        "    def calculate_loss(self, y, ytrue, n=9, lamda=0.01, is_training=True):\n",
        "        loss = self.vm.vox_morph_loss(y, ytrue, n, lamda)\n",
        "        return loss\n",
        "\n",
        "    def train_model(self, batch_moving, batch_fixed, n=9, lamda=0.01, return_metric_score=True):\n",
        "        self.optimizer.zero_grad()\n",
        "        batch_fixed, batch_moving = batch_fixed.to(self.device), batch_moving.to(self.device)\n",
        "        registered_image, _ = self.voxelmorph(batch_moving, batch_fixed)\n",
        "        print(batch_fixed.shape)\n",
        "        train_loss = self.calculate_loss(registered_image, batch_fixed, n, lamda)\n",
        "        train_loss.backward()\n",
        "        self.optimizer.step()\n",
        "        if return_metric_score:\n",
        "            train_dice_score = self.vm.dice_score(registered_image, batch_fixed)\n",
        "            return train_loss, train_dice_score\n",
        "        return train_loss\n",
        "\n",
        "    def get_test_loss(self, batch_moving, batch_fixed, n=9, lamda=0.01):\n",
        "        with torch.set_grad_enabled(False):\n",
        "            registered_image, _ = self.voxelmorph(batch_moving, batch_fixed)\n",
        "            val_loss = self.vm.vox_morph_loss(registered_image, batch_fixed, n, lamda)\n",
        "            val_dice_score = self.vm.dice_score(registered_image, batch_fixed)\n",
        "            return val_loss, val_dice_score"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MiR8kEs1JxwG"
      },
      "source": [
        "# def main():\n",
        "#     '''\n",
        "#     In this I'll take example of FIRE: Fundus Image Registration Dataset\n",
        "#     to demostrate the working of the API.\n",
        "#     '''\n",
        "#     vm = VoxelMorph((1, 32, 32), is_2d=True)  # Object of the higher level class\n",
        "#     # DATA_PATH = './fire-fundus-image-registration-dataset/'\n",
        "#     params = {'batch_size': 1,\n",
        "#               'shuffle': True,\n",
        "#               'num_workers': 6,\n",
        "#               'worker_init_fn': np.random.seed(42)\n",
        "#               }\n",
        "\n",
        "#     max_epochs = 2\n",
        "#     # filename = list(set([x.split('_')[0]\n",
        "#     #                      for x in os.listdir('./fire-fundus-image-registration-dataset/')]))\n",
        "#     # partition = {}\n",
        "#     # partition['train'], partition['validation'] = train_test_split(\n",
        "#     #     filename, test_size=0.33, random_state=42)\n",
        "\n",
        "#     # # Generators\n",
        "#     # training_set = Dataset(partition['train'])\n",
        "#     # training_generator = data.DataLoader(training_set, **params)\n",
        "\n",
        "#     # validation_set = Dataset(partition['validation'])\n",
        "#     # validation_generator = data.DataLoader(validation_set, **params)\n",
        "\n",
        "#     # Loop over epochs\n",
        "#     for epoch in range(max_epochs):\n",
        "#         start_time = time.time()\n",
        "#         train_loss = 0\n",
        "#         train_dice_score = 0\n",
        "#         val_loss = 0\n",
        "#         val_dice_score = 0\n",
        "#         for batch_moving, batch_fixed in training_generator:\n",
        "#             loss, dice = vm.train_model(batch_moving, batch_fixed)\n",
        "#             train_dice_score += dice.data\n",
        "#             train_loss += loss.data\n",
        "#         print('[', \"{0:.2f}\".format((time.time() - start_time) / 60), 'mins]', 'After', epoch + 1, 'epochs, the Average training loss is ', train_loss *\n",
        "#               params['batch_size'] / len(training_set), 'and average DICE score is', train_dice_score.data * params['batch_size'] / len(training_set))\n",
        "#         # Testing time\n",
        "#         start_time = time.time()\n",
        "#         for batch_moving, batch_fixed in validation_generator:\n",
        "#             # print(batch_moving.shape)\n",
        "#             # Transfer to GPU\n",
        "#             loss, dice = vm.get_test_loss(batch_moving, batch_fixed)\n",
        "#             val_dice_score += dice.data\n",
        "#             val_loss += loss.data\n",
        "#         print('[', \"{0:.2f}\".format((time.time() - start_time) / 60), 'mins]', 'After', epoch + 1, 'epochs, the Average validations loss is ', val_loss *\n",
        "#               params['batch_size'] / len(validation_set), 'and average DICE score is', val_dice_score.data * params['batch_size'] / len(validation_set))\n",
        "\n",
        "# if __name__ == \"__main__\":\n",
        "#     main()\n",
        "    "
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h5V7Oix6Oxi0"
      },
      "source": [
        "## 3. GANs"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XC49B04qO9Rh"
      },
      "source": [
        "def add_conv_stage(dim_in, dim_out, kernel_size = 4, stride = 2, padding = 1, bias = False):\n",
        "  return nn.Sequential(\n",
        "      nn.Conv2d(dim_in, dim_out, kernel_size=kernel_size, stride=stride, padding=padding, bias=bias),\n",
        "      nn.BatchNorm2d(dim_out),\n",
        "      nn.LeakyReLU(0.2, inplace=True)\n",
        "  )\n",
        "  \n",
        "  ## Define discriminator\n",
        "class discriminator(nn.Module):\n",
        "    # initializers\n",
        "    def __init__(self):\n",
        "        super(discriminator, self).__init__()\n",
        "        self.layers = nn.Sequential(\n",
        "            nn.Conv2d(1, 64, 4, 2, 1, bias=False),\n",
        "            nn.LeakyReLU(0.2, inplace=True),\n",
        "            add_conv_stage(64, 128),\n",
        "            add_conv_stage(128, 256),\n",
        "            add_conv_stage(256, 512),\n",
        "            nn.Conv2d(512, 1, 4,2,1, bias = False),\n",
        "            nn.LeakyReLU(0.2),\n",
        "            nn.Sigmoid()\n",
        "        )\n",
        "\n",
        "    # weight_init\n",
        "    def weight_init(self, mean, std):\n",
        "        for m in self._modules:\n",
        "            normal_init(self._modules[m], mean, std)\n",
        "\n",
        "    # forward method\n",
        "    def forward(self, input):\n",
        "        return self.layers(input)\n"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1LTon_RaY3y3"
      },
      "source": [
        "## Generator\n",
        "vm = VoxelMorph((1, 32, 32), is_2d=True,  use_gpu=True)  # Object of the higher level class\n",
        "\n",
        "generator = vm.voxelmorph\n"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JaX406BkE1XY"
      },
      "source": [
        "def weights_init(m):\n",
        "    classname = m.__class__.__name__\n",
        "    if classname.find('Conv') != -1:\n",
        "        nn.init.normal_(m.weight.data, 0.0, 0.02)\n",
        "    elif classname.find('BatchNorm') != -1:\n",
        "        nn.init.normal_(m.weight.data, 1.0, 0.02)\n",
        "        nn.init.constant_(m.bias.data, 0)"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4LCNxPF_c4op",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1731bec0-bc66-4a9c-ca8d-4478c452c398"
      },
      "source": [
        "D = discriminator()\n",
        "G = generator\n",
        "\n",
        "lr_g = 2e-4\n",
        "lr_d = 1e-4\n",
        "\n",
        "D_losses = []\n",
        "G_losses = []\n",
        "G_losses_total = []\n",
        "\n",
        "BCELoss = nn.BCELoss()\n",
        "MSELoss = nn.MSELoss()\n",
        "KLDiveLoss = nn.KLDivLoss()\n",
        "\n",
        "SmoothingLoss = vm2d.smooothing_loss\n",
        "\n",
        "G_optimizer = optim.Adam(G.parameters(), lr=lr_g, betas=(.5, 0.999))\n",
        "# D_optimizer = optim.Adam(D.parameters(), lr=lr_d, betas=(.5, 0.999))\n",
        "D_optimizer = optim.SGD(D.parameters(), lr=lr_d)\n",
        "\n",
        "if use_gpu:\n",
        "    G = G.cuda()\n",
        "    D = D.cuda()\n",
        "D.apply(weights_init)\n",
        "G.apply(weights_init)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "VoxelMorph2d(\n",
              "  (unet): UNet(\n",
              "    (conv_encode1): Sequential(\n",
              "      (0): Conv2d(2, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "      (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (2): ReLU()\n",
              "      (3): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "      (4): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (5): ReLU()\n",
              "    )\n",
              "    (conv_maxpool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
              "    (conv_encode2): Sequential(\n",
              "      (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "      (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (2): ReLU()\n",
              "      (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "      (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (5): ReLU()\n",
              "    )\n",
              "    (conv_maxpool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
              "    (conv_encode3): Sequential(\n",
              "      (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "      (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (2): ReLU()\n",
              "      (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "      (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (5): ReLU()\n",
              "    )\n",
              "    (conv_maxpool3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
              "    (dropout): Dropout2d(p=0.3, inplace=False)\n",
              "    (bottleneck): Sequential(\n",
              "      (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "      (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (2): ReLU()\n",
              "      (3): Conv2d(256, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "      (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (5): ReLU()\n",
              "      (6): ConvTranspose2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n",
              "      (7): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (8): ReLU()\n",
              "    )\n",
              "    (conv_decode3): Sequential(\n",
              "      (0): Conv2d(256, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "      (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (2): ReLU()\n",
              "      (3): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "      (4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (5): ReLU()\n",
              "      (6): ConvTranspose2d(128, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n",
              "      (7): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (8): ReLU()\n",
              "    )\n",
              "    (conv_decode2): Sequential(\n",
              "      (0): Conv2d(128, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "      (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (2): ReLU()\n",
              "      (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "      (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (5): ReLU()\n",
              "      (6): ConvTranspose2d(64, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n",
              "      (7): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (8): ReLU()\n",
              "    )\n",
              "    (final_layer): Sequential(\n",
              "      (0): Conv2d(64, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "      (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (2): ReLU()\n",
              "      (3): Conv2d(32, 2, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
              "      (4): BatchNorm2d(2, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
              "      (5): Tanh()\n",
              "    )\n",
              "  )\n",
              "  (spatial_transform): SpatialTransformation()\n",
              ")"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FVwO6M9C-aIO",
        "outputId": "00582f7d-8ab5-4467-8ab9-9ede132cd0a6"
      },
      "source": [
        "epochs = 80\n",
        "train_interval = 5\n",
        "for epoch in range(epochs):\n",
        "    \n",
        "    for batch_moving, batch_fixed in training_generator:\n",
        "\n",
        "        mini_batch = batch_moving.shape[0]\n",
        "\n",
        "        y_real_ = torch.ones(mini_batch)\n",
        "        y_fake_ = torch.zeros(mini_batch)\n",
        "\n",
        "        if use_gpu:\n",
        "            y_real_ = y_real_.cuda()\n",
        "            y_fake_ = y_fake_.cuda()\n",
        "            batch_moving = batch_moving.cuda()\n",
        "            batch_fixed = batch_fixed.cuda()\n",
        "\n",
        "        batch_fixed_reorder = batch_fixed.permute(0, 3, 1, 2)\n",
        "        batch_moving_reorder = batch_moving.permute(0, 3, 1, 2)\n",
        "\n",
        "        # Train discriminator D\n",
        "        D.zero_grad()\n",
        "        D_real = D(batch_moving_reorder).view(-1)\n",
        "        # D_real = D(batch_fixed_reorder).view(-1)\n",
        "\n",
        "        D_real_loss = BCELoss(D_real, Variable(y_real_))\n",
        "        D_real_loss.backward()\n",
        "\n",
        "        with torch.no_grad():\n",
        "            dat_fake, _ = G(batch_moving, batch_fixed)\n",
        "        dat_fake_reorder = dat_fake.permute(0, 3, 1, 2)\n",
        "\n",
        "        D_fake = D(dat_fake_reorder).view(-1)\n",
        "        D_fake_loss = BCELoss(D_fake, Variable(y_fake_))\n",
        "        D_fake_loss.backward()\n",
        "\n",
        "        D_optimizer.step()\n",
        "        D_train_loss = D_real_loss + D_fake_loss\n",
        "        D_losses.append(D_train_loss.data.item())\n",
        "\n",
        "        # Train generator G\n",
        "        for iter in range(train_interval):\n",
        "\n",
        "            G.zero_grad()\n",
        "            dat_fake, _ = G(batch_moving, batch_fixed)\n",
        "            dat_fake_reorder = dat_fake.permute(0, 3, 1, 2)\n",
        "\n",
        "            with torch.no_grad():\n",
        "              D_fake = D(dat_fake_reorder).view(-1)\n",
        "            G_train_loss = BCELoss(D_fake, Variable(y_real_))\n",
        "            G_train_loss_total = G_train_loss + 1e-3*MSELoss(dat_fake, batch_fixed)+1e-3*SmoothingLoss(dat_fake)\n",
        "\n",
        "            G_train_loss_total.backward()\n",
        "            G_optimizer.step()\n",
        "            G_losses.append(G_train_loss.data.item())\n",
        "            G_losses_total.append(G_train_loss_total.data.item())\n",
        "\n",
        "    print('[%d/%d] - loss_d: %.3f, loss_g: %.3f, loss_g_total: %.3f' % ((epoch + 1), epochs,\n",
        "                                                    torch.mean(torch.FloatTensor(D_losses)),\n",
        "                                                    torch.mean(torch.FloatTensor(G_losses)),\n",
        "                                                    torch.mean(torch.FloatTensor(G_losses_total))))\n"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1/80] - loss_d: 1.399, loss_g: 0.768, loss_g_total: 4.640\n",
            "[2/80] - loss_d: 1.393, loss_g: 0.764, loss_g_total: 4.321\n",
            "[3/80] - loss_d: 1.387, loss_g: 0.760, loss_g_total: 4.161\n",
            "[4/80] - loss_d: 1.381, loss_g: 0.756, loss_g_total: 4.065\n",
            "[5/80] - loss_d: 1.375, loss_g: 0.751, loss_g_total: 3.993\n",
            "[6/80] - loss_d: 1.367, loss_g: 0.744, loss_g_total: 3.938\n",
            "[7/80] - loss_d: 1.358, loss_g: 0.738, loss_g_total: 3.893\n",
            "[8/80] - loss_d: 1.348, loss_g: 0.730, loss_g_total: 3.856\n",
            "[9/80] - loss_d: 1.336, loss_g: 0.723, loss_g_total: 3.824\n",
            "[10/80] - loss_d: 1.324, loss_g: 0.717, loss_g_total: 3.798\n",
            "[11/80] - loss_d: 1.312, loss_g: 0.712, loss_g_total: 3.774\n",
            "[12/80] - loss_d: 1.300, loss_g: 0.708, loss_g_total: 3.754\n",
            "[13/80] - loss_d: 1.287, loss_g: 0.705, loss_g_total: 3.737\n",
            "[14/80] - loss_d: 1.275, loss_g: 0.702, loss_g_total: 3.723\n",
            "[15/80] - loss_d: 1.264, loss_g: 0.700, loss_g_total: 3.710\n",
            "[16/80] - loss_d: 1.252, loss_g: 0.698, loss_g_total: 3.699\n",
            "[17/80] - loss_d: 1.241, loss_g: 0.697, loss_g_total: 3.689\n",
            "[18/80] - loss_d: 1.231, loss_g: 0.696, loss_g_total: 3.680\n",
            "[19/80] - loss_d: 1.220, loss_g: 0.695, loss_g_total: 3.672\n",
            "[20/80] - loss_d: 1.211, loss_g: 0.695, loss_g_total: 3.665\n",
            "[21/80] - loss_d: 1.201, loss_g: 0.694, loss_g_total: 3.658\n",
            "[22/80] - loss_d: 1.192, loss_g: 0.694, loss_g_total: 3.652\n",
            "[23/80] - loss_d: 1.183, loss_g: 0.694, loss_g_total: 3.647\n",
            "[24/80] - loss_d: 1.174, loss_g: 0.695, loss_g_total: 3.642\n",
            "[25/80] - loss_d: 1.165, loss_g: 0.695, loss_g_total: 3.638\n",
            "[26/80] - loss_d: 1.157, loss_g: 0.695, loss_g_total: 3.634\n",
            "[27/80] - loss_d: 1.149, loss_g: 0.696, loss_g_total: 3.630\n",
            "[28/80] - loss_d: 1.141, loss_g: 0.696, loss_g_total: 3.627\n",
            "[29/80] - loss_d: 1.134, loss_g: 0.697, loss_g_total: 3.623\n",
            "[30/80] - loss_d: 1.126, loss_g: 0.698, loss_g_total: 3.621\n",
            "[31/80] - loss_d: 1.119, loss_g: 0.698, loss_g_total: 3.619\n",
            "[32/80] - loss_d: 1.112, loss_g: 0.699, loss_g_total: 3.617\n",
            "[33/80] - loss_d: 1.105, loss_g: 0.700, loss_g_total: 3.615\n",
            "[34/80] - loss_d: 1.099, loss_g: 0.701, loss_g_total: 3.613\n",
            "[35/80] - loss_d: 1.092, loss_g: 0.702, loss_g_total: 3.611\n",
            "[36/80] - loss_d: 1.086, loss_g: 0.703, loss_g_total: 3.609\n",
            "[37/80] - loss_d: 1.079, loss_g: 0.704, loss_g_total: 3.608\n",
            "[38/80] - loss_d: 1.073, loss_g: 0.705, loss_g_total: 3.606\n",
            "[39/80] - loss_d: 1.067, loss_g: 0.706, loss_g_total: 3.605\n",
            "[40/80] - loss_d: 1.062, loss_g: 0.707, loss_g_total: 3.604\n",
            "[41/80] - loss_d: 1.056, loss_g: 0.708, loss_g_total: 3.602\n",
            "[42/80] - loss_d: 1.050, loss_g: 0.709, loss_g_total: 3.601\n",
            "[43/80] - loss_d: 1.045, loss_g: 0.710, loss_g_total: 3.600\n",
            "[44/80] - loss_d: 1.040, loss_g: 0.711, loss_g_total: 3.600\n",
            "[45/80] - loss_d: 1.034, loss_g: 0.713, loss_g_total: 3.599\n",
            "[46/80] - loss_d: 1.029, loss_g: 0.714, loss_g_total: 3.598\n",
            "[47/80] - loss_d: 1.024, loss_g: 0.715, loss_g_total: 3.598\n",
            "[48/80] - loss_d: 1.019, loss_g: 0.716, loss_g_total: 3.597\n",
            "[49/80] - loss_d: 1.014, loss_g: 0.718, loss_g_total: 3.596\n",
            "[50/80] - loss_d: 1.009, loss_g: 0.719, loss_g_total: 3.597\n",
            "[51/80] - loss_d: 1.005, loss_g: 0.720, loss_g_total: 3.596\n",
            "[52/80] - loss_d: 1.000, loss_g: 0.722, loss_g_total: 3.596\n",
            "[53/80] - loss_d: 0.995, loss_g: 0.723, loss_g_total: 3.596\n",
            "[54/80] - loss_d: 0.991, loss_g: 0.724, loss_g_total: 3.596\n",
            "[55/80] - loss_d: 0.986, loss_g: 0.726, loss_g_total: 3.596\n",
            "[56/80] - loss_d: 0.982, loss_g: 0.727, loss_g_total: 3.596\n",
            "[57/80] - loss_d: 0.977, loss_g: 0.729, loss_g_total: 3.597\n",
            "[58/80] - loss_d: 0.973, loss_g: 0.730, loss_g_total: 3.597\n",
            "[59/80] - loss_d: 0.969, loss_g: 0.732, loss_g_total: 3.597\n",
            "[60/80] - loss_d: 0.965, loss_g: 0.733, loss_g_total: 3.598\n",
            "[61/80] - loss_d: 0.960, loss_g: 0.735, loss_g_total: 3.598\n",
            "[62/80] - loss_d: 0.956, loss_g: 0.736, loss_g_total: 3.599\n",
            "[63/80] - loss_d: 0.952, loss_g: 0.738, loss_g_total: 3.599\n",
            "[64/80] - loss_d: 0.948, loss_g: 0.740, loss_g_total: 3.600\n",
            "[65/80] - loss_d: 0.944, loss_g: 0.741, loss_g_total: 3.600\n",
            "[66/80] - loss_d: 0.940, loss_g: 0.743, loss_g_total: 3.601\n",
            "[67/80] - loss_d: 0.936, loss_g: 0.745, loss_g_total: 3.602\n",
            "[68/80] - loss_d: 0.933, loss_g: 0.746, loss_g_total: 3.602\n",
            "[69/80] - loss_d: 0.929, loss_g: 0.748, loss_g_total: 3.603\n",
            "[70/80] - loss_d: 0.925, loss_g: 0.750, loss_g_total: 3.604\n",
            "[71/80] - loss_d: 0.921, loss_g: 0.752, loss_g_total: 3.605\n",
            "[72/80] - loss_d: 0.918, loss_g: 0.753, loss_g_total: 3.606\n",
            "[73/80] - loss_d: 0.914, loss_g: 0.755, loss_g_total: 3.607\n",
            "[74/80] - loss_d: 0.911, loss_g: 0.757, loss_g_total: 3.608\n",
            "[75/80] - loss_d: 0.907, loss_g: 0.759, loss_g_total: 3.609\n",
            "[76/80] - loss_d: 0.904, loss_g: 0.761, loss_g_total: 3.610\n",
            "[77/80] - loss_d: 0.900, loss_g: 0.763, loss_g_total: 3.611\n",
            "[78/80] - loss_d: 0.897, loss_g: 0.765, loss_g_total: 3.612\n",
            "[79/80] - loss_d: 0.893, loss_g: 0.767, loss_g_total: 3.613\n",
            "[80/80] - loss_d: 0.890, loss_g: 0.769, loss_g_total: 3.614\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "TH1vaBFwIhfx",
        "outputId": "a8a8b54f-5e90-4ab7-bd55-968f5cee8602"
      },
      "source": [
        "#Plotting:\n",
        "\n",
        "#Losses:\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.plot(D_losses)\n",
        "plt.title(\"D Loss\")\n",
        "plt.xlabel(\"Batch number\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.plot(G_losses)\n",
        "plt.title(\"G Loss\")\n",
        "plt.xlabel(\"Batch number\")\n",
        "plt.ylabel(\"Loss\");"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I7HjH6n8Ky2I"
      },
      "source": [
        "val_moving = validation_set[0:10][0]\n",
        "val_fixed = validation_set[0:10][1]\n",
        "\n",
        "if use_gpu:\n",
        "  val_moving = val_moving.cuda()\n",
        "  val_fixed = val_fixed.cuda()\n",
        "\n",
        "val_registered, defor = G(val_moving, val_fixed)"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 180
        },
        "id": "mqLlVVmmLV23",
        "outputId": "70eaa988-a197-4be0-edad-6cb57f422d9a"
      },
      "source": [
        "plt.subplot(1,3,1)\n",
        "plt.imshow(val_registered[0].cpu().data.numpy().squeeze(),cmap='gray', interpolation='none')\n",
        "plt.title(\"Registered Image\")\n",
        "plt.subplot(1,3,2)\n",
        "plt.imshow(val_fixed[0].cpu().data.numpy().squeeze(),cmap='gray', interpolation='none')\n",
        "plt.title(\"Fixed Image\")\n",
        "plt.subplot(1,3,3)\n",
        "plt.imshow(val_moving[0].cpu().data.numpy().squeeze(),cmap='gray', interpolation='none')\n",
        "plt.title(\"Moving Image\")\n"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Moving Image')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 3 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W72fRqRqV2gI",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 405
        },
        "outputId": "7eab7812-a434-4720-c733-75bb0818edb3"
      },
      "source": [
        "# !pip install neurite\r\n",
        "import neurite as ne\r\n",
        "ne.plot.flow([defor[1].cpu().data.numpy().squeeze()], width = 5)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(<Figure size 360x360 with 1 Axes>,\n",
              " [<matplotlib.axes._subplots.AxesSubplot at 0x7fc931955ef0>])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    }
  ]
}